home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / emerald / emrldsys.lha / EC / OperationNames / OpNameServer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-08-16  |  6.4 KB  |  277 lines
  1. #include <sys/types.h>
  2. #include <sys/socket.h>
  3. #include <sys/time.h>
  4. #include <netinet/in.h>
  5. #include <netdb.h>
  6. #include <fcntl.h>
  7. #include <signal.h>
  8. #include <stdio.h>
  9.  
  10. #define SOCKETNUMBER 2019
  11.  
  12. #define IN_HANDLER 0x0010
  13. #define OUT_HANDLER 0x0020
  14. #define BOTH_HANDLER (IN_HANDLER | OUT_HANDLER)
  15.  
  16. extern int errno;
  17. #include <errno.h>
  18.  
  19. #ifdef NDEBUG
  20. #define DebugMessage()
  21. #else
  22. static int debugging = 0;
  23. static void DebugMessage(format, args)
  24. char *format;
  25. int args;
  26. {
  27.   if (debugging) {
  28.     _doprnt(format, &args, stdout);
  29.     fflush(stdout);
  30.   }
  31. }
  32. #endif
  33.  
  34. #ifdef CHECKOUTSOCKETS
  35. void checkOutSocket(socket)
  36. int socket;
  37. {
  38.   int owner, flags;
  39.   owner = fcntl(socket, F_GETOWN, 0);
  40.   DebugMessage("the socket %d owner is %d\n", socket, owner);
  41.   flags = fcntl(socket, F_GETFL, 0);
  42.   DebugMessage("flags:");
  43.   if (flags & FASYNC) DebugMessage("FASYNC ");
  44.   if (flags & FNDELAY) DebugMessage("FNDELAY ");
  45.   if (flags & FAPPEND) DebugMessage("FAPPEND ");
  46.   DebugMessage("\n");
  47. }
  48. #endif
  49.  
  50. typedef int (*PFI)();
  51. static PFI inHandlers[32], outHandlers[32];
  52. static int inMask, outMask;
  53. static int nfds = 0;
  54.  
  55. void panic(S)
  56. char *S;
  57. {
  58.   perror(S);
  59.   exit(1);
  60. }
  61. static struct timeval zero = {0, 0};
  62. static int requestSocket;
  63.  
  64. int sigIOHandler()
  65. {
  66.   int nfound, infds, outfds, nextfd;
  67. #ifdef ASYCHRONOUS
  68.   DebugMessage("Got a sig IO\n");
  69. #else
  70. /*  DebugMessage("Waiting for a message\n"); */
  71. #endif
  72. #ifdef CHECKOUTSOCKETS
  73.   checkOutSocket(requestSocket);
  74. #endif
  75.   infds = inMask;
  76.   outfds = outMask;
  77. #ifdef ASYNCHRONOUS
  78.   nfound = select(nfds, &infds, &outfds, 0, &zero);
  79. #else
  80.   nfound = select(nfds, &infds, &outfds, 0, 0);
  81. #endif
  82.   if (nfound == 0) DebugMessage(
  83.     "sigIOHandler: select %d in = 0x%08x out = 0x%08x\n",
  84.     nfound, infds, outfds);
  85.   if (nfound < 0) panic("sigIOHandler: (accept)");
  86.   if (nfound > 0) {
  87.     while ((nextfd = myffs(infds)) < 32) {
  88.       infds &= ~ (1 << nextfd);
  89.       (*inHandlers[nextfd])(nextfd, IN_HANDLER);
  90.     }
  91.     while ((nextfd = myffs(outfds)) < 32) {
  92.       outfds &= ~ (1 << nextfd);
  93.       (*outHandlers[nextfd])(nextfd, OUT_HANDLER);
  94.     
  95.     }
  96.   }
  97. }
  98.  
  99. void tearDown(socket)
  100. int socket;
  101. {
  102.   int i;
  103.   inMask &= ~ (1 << socket);
  104.   outMask &= ~ (1 << socket);
  105.   if (socket == nfds - 1) {
  106.     nfds = 0;
  107.     i = myffs(inMask);
  108.     if (i < 32) nfds = i + 1;
  109.     i = myffs(outMask);
  110.     if (i < 32 && i > nfds - 1) nfds = i + 1;
  111.   }
  112.   inHandlers[socket] = NULL;
  113.   outHandlers[socket] = NULL;
  114.   close(socket);
  115. }
  116.  
  117. int myffs(x)
  118. int x;
  119. {
  120.   register int r;
  121.   r = ffs(x);
  122.   return r == 0 ? 32 : r - 1;
  123. }
  124.  
  125. void establishHandler(socket, handler, inout)
  126. int socket, inout;
  127. int (*handler)();
  128. {
  129.   if (socket >= nfds) nfds = socket + 1;
  130.   if (inout & IN_HANDLER) {
  131.     inHandlers[socket] = handler;
  132.     inMask |= (1 << socket);
  133.   }
  134.   if (inout & OUT_HANDLER) {
  135.     outHandlers[socket] = handler;
  136.     outMask |= (1 << socket);
  137.   }
  138. }
  139.  
  140. static int requestHandler(socket, inout)
  141. int socket, inout;
  142. {
  143.   char requestBuffer[128], operationName[128], opCode;
  144.   int theOID;
  145.  
  146.   receive(socket, requestBuffer);
  147.   if (*requestBuffer == '\0') {
  148.     DebugMessage("End of file -- checkpointing\n");
  149.     ON_finalize();
  150.     tearDown(socket);
  151.   } else {
  152.     DebugMessage("Request: %s", requestBuffer);
  153.     if (sscanf(requestBuffer, "%c", &opCode) != 1) {
  154.       panic("requestHandler: (sscanf - bogus message)");
  155.     }
  156.     switch (opCode) {
  157.       case 'T':
  158.     if (sscanf(requestBuffer, "%*c %s\n", operationName) != 1) {
  159.       panic("requestHandler: (sscanf - bogus message)");
  160.     }
  161.     theOID = ON_Translate(operationName);
  162.     sprintf(requestBuffer, "T 0x%08x\n", theOID);
  163.     break;
  164.       case 'A':
  165.     theOID = AllocateOIDS();
  166.     sprintf(requestBuffer, "A 0x%08x\n", theOID);
  167.     break;
  168.       case 'N':
  169.     if (sscanf(requestBuffer, "%*c 0x%x\n", &theOID) != 1) {
  170.       panic("requestHandler: (sscanf - bogus message)");
  171.     }
  172.     sprintf(requestBuffer, "N %s\n", ON_Name(theOID));
  173.     break;
  174.       default:
  175.     panic("requestHandler: (switch)");
  176.     break;
  177.     }
  178.     DebugMessage("Result : %s", requestBuffer);
  179.     send(socket, requestBuffer);
  180.   }
  181. }
  182.  
  183. int acceptRequestHandler(socket, inout)
  184. int socket, inout;
  185. {
  186.   int newfd;
  187.   struct sockaddr_in addr;
  188.   int addr_length = sizeof(addr);
  189.   DebugMessage("Got an accept request inout = 0x%08x\n", inout);
  190.   newfd = accept(requestSocket, &addr, &addr_length);
  191.   if (newfd < 0) {
  192.     if (errno == EWOULDBLOCK) {
  193.       DebugMessage("Would block from acceptrequestHandler.accept\n");
  194.     } else panic("acceptRequestHandler: (accept)");
  195.   } else {
  196.     DebugMessage("acceptRequestHandler accept new socket = %d\n", newfd);
  197. #ifdef CHECKOUTSOCKET
  198.     checkOutSocket(newfd);
  199. #endif
  200.     if (fcntl(newfd, F_SETFL, FASYNC | FNDELAY) < 0) {
  201.       panic("new socket: (first fcntl)");
  202.     }
  203.     if (fcntl(newfd, F_SETOWN, -getpid()) < 0) {
  204.       panic("new socket: (second fcntl)");
  205.     }
  206.     establishHandler(newfd, requestHandler, IN_HANDLER);
  207.   }
  208. }
  209.  
  210. void establishSocket()
  211. {
  212.   struct sockaddr_in requestSocketAddress;
  213.   char              myHostName[100];
  214.   struct hostent   *myHost;
  215.  
  216.   bzero(&requestSocketAddress, sizeof(requestSocketAddress));
  217.   requestSocket = socket(AF_INET, SOCK_STREAM, 0, 0);
  218.   if (requestSocket < 0) panic("establishSocket: (socket)");
  219.  
  220.   requestSocketAddress.sin_family = AF_INET;
  221.   if (gethostname(myHostName, 100) < 0) {
  222.       panic("establishConnection: gethostname");
  223.   }
  224.   myHost = gethostbyname(myHostName);
  225.   if (myHost == NULL) {
  226.       panic("establishConnection: gethostbyname");
  227.   }
  228.   bcopy(myHost->h_addr, &requestSocketAddress.sin_addr, myHost->h_length);
  229.   requestSocketAddress.sin_port = htons(((short int)SOCKETNUMBER));
  230.   if (bind(requestSocket, &requestSocketAddress, sizeof(requestSocketAddress), 0) < 0) {
  231.     panic("establishSocket: (bind)");
  232.   }
  233.  
  234. #ifdef ASYNCHRONOUS
  235.   if (fcntl(requestSocket, F_SETFL, FASYNC | FNDELAY) < 0) {
  236.     panic("establishSocket: (first fcntl)");
  237.   }
  238. #endif
  239.   DebugMessage("My pid %d\n", getpid());
  240. #ifdef CHECKOUTSOCKET
  241.   checkOutSocket(requestSocket);
  242. #endif
  243. #ifdef ASYNCHRONOUS
  244.   if (fcntl(requestSocket, F_SETOWN, -getpid()) < 0) {
  245.     panic("establishSocket: (second fcntl)");
  246.   }
  247. #endif
  248.   establishHandler(requestSocket, acceptRequestHandler, IN_HANDLER);
  249.   listen(requestSocket, 5);
  250. }
  251.  
  252. main(argc, argv)
  253. int argc;
  254. char **argv;
  255. {
  256.   struct sigvec sv;
  257.   int i;
  258.   sv.sv_mask = 0;
  259.   sv.sv_onstack = 0;
  260. #ifdef ASYNCHRONOUS
  261.   sv.sv_handler = sigIOHandler;
  262.   sigvec(SIGIO, &sv, NULL);
  263. #endif
  264.   sv.sv_handler = SIG_IGN;
  265.   sigvec(SIGPIPE, &sv, NULL);
  266.  
  267.   ON_initialize();
  268.   establishSocket();
  269.   while(1) {
  270. #ifdef ASYNCHRONOUS
  271.     sigpause(0);
  272. #else
  273.     sigIOHandler();
  274. #endif
  275.   }
  276. }
  277.